const request = require('~/api/request.js').default;
const config = require('~/config/index.js').default;

Page({
  data: {
    loading: false,
    userInfo: null,
    hasUserInfo: false
  },

  onLoad() {
    console.log('登录页面加载');
    // 检查是否已经登录
    this.checkLoginStatus();
  },

  /**
   * 检查登录状态
   */
  checkLoginStatus() {
    const userInfo = wx.getStorageSync('userInfo');
    const userId = wx.getStorageSync('userId');
    
    // 只有当用户信息完整时才自动跳转
    if (userInfo && userId && userInfo.nickName && userInfo.avatarUrl) {
      console.log('用户已完整登录，跳转到首页');
      this.setData({
        userInfo: userInfo,
        hasUserInfo: true
      });
      
      // 延迟跳转，让用户看到登录成功状态
      setTimeout(() => {
        wx.switchTab({
          url: '/pages/home/index'
        });
      }, 1500);
    } else if (userInfo && userId) {
      console.log('用户已登录但信息不完整，需要完善信息');
      this.setData({
        userInfo: userInfo,
        hasUserInfo: false
      });
    }
  },

  /**
   * 微信登录
   */
  async wxLogin() {
    if (this.data.loading) return;
    
    this.setData({ loading: true });
    
    try {
      console.log('开始微信登录流程');
      
      // 1. 调用 wx.login 获取临时登录凭证
      const loginResult = await this.getWxLoginCode();
      if (!loginResult.success) {
        throw new Error(loginResult.error);
      }

      // 2. 将 code 发送给后端，换取 openid 和 session_key
      const authResult = await this.code2Session(loginResult.code);
      if (!authResult.success) {
        throw new Error(authResult.error);
      }

      // 保存 openid 到本地存储
      wx.setStorageSync('openid', authResult.openid);

      // 3. 根据登录结果处理用户信息
      console.log('准备调用 handleLoginResult，authResult:', authResult);
      await this.handleLoginResult(authResult);

    } catch (error) {
      console.error('微信登录失败:', error);
      wx.showToast({
        title: '登录失败: ' + error.message,
        icon: 'none',
        duration: 3000
      });
    } finally {
      this.setData({ loading: false });
    }
  },

  /**
   * 获取微信登录凭证
   */
  getWxLoginCode() {
    return new Promise((resolve) => {
      wx.login({
        success: (res) => {
          console.log('wx.login 成功:', res);
          resolve({
            success: true,
            code: res.code
          });
        },
        fail: (err) => {
          console.error('wx.login 失败:', err);
          resolve({
            success: false,
            error: '获取登录凭证失败'
          });
        }
      });
    });
  },

  /**
   * 调用后端接口，将 code 换取 openid 和 session_key
   */
  async code2Session(code) {
    try {
      const response = await request('/user/login', 'POST', { code: code });
      
      console.log('后端登录接口返回:', response);
      
      if (response.code === 200) {
        const result = {
          success: true,
          openid: response.data.openid,
          sessionKey: response.data.sessionKey,
          userId: response.data.id, // 后端返回的是 id 字段
          accessToken: response.data.accessToken, // JWT访问令牌
          userInfo: {
            nickName: response.data.nickName,
            avatarUrl: response.data.avatarUrl,
            gender: response.data.gender,
            country: response.data.country,
            province: response.data.province,
            city: response.data.city,
            language: response.data.language,
            title: response.data.title // 添加用户称号
          },
          newUser: response.data.newUser, // 新增：是否新用户标识
          userData: response.data // 保存完整的用户数据
        };
        
        console.log('code2Session 处理后的结果:', result);
        return result;
      } else {
        return {
          success: false,
          error: response.message || '登录失败'
        };
      }
    } catch (error) {
      console.error('code2Session 请求失败:', error);
      return {
        success: false,
        error: '网络请求失败'
      };
    }
  },

  /**
   * 处理登录结果
   */
  async handleLoginResult(authResult) {
    try {
      // 根据后端返回的 newUser 字段判断是否为新用户
      console.log('判断用户类型，newUser:', authResult.newUser, 'userId:', authResult.userId);
      
      if (authResult.newUser) {
        // 新用户，需要获取用户信息
        console.log('检测到新用户，用户ID:', authResult.userId);
        
        // 保存新用户的基础信息到本地存储
        wx.setStorageSync('userId', authResult.userId);
        wx.setStorageSync('openid', authResult.openid);
        // 保存JWT令牌
        if (authResult.accessToken) {
          wx.setStorageSync('access_token', authResult.accessToken);
          console.log('保存JWT令牌成功:', authResult.accessToken.substring(0, 20) + '...');
        } else {
          console.warn('authResult中没有accessToken字段');
        }
        
        // 确保页面状态为未登录，这样弹窗才能正常显示
        this.setData({
          hasUserInfo: false,
          userInfo: null,
          loading: false
        });
        
        console.log('准备显示获取用户信息弹窗');
        // 显示获取用户信息的弹窗
        this.showGetUserInfoModal();
      } else {
        // 老用户
        console.log('老用户登录成功，用户ID:', authResult.userId);
        
        // 检查是否有完整的用户信息（昵称和头像）
        const userInfo = authResult.userInfo;
        if (userInfo && userInfo.nickName && userInfo.avatarUrl) {
          // 有完整的用户信息，先保存JWT令牌，再登录成功
          if (authResult.accessToken) {
            wx.setStorageSync('access_token', authResult.accessToken);
            console.log('老用户保存JWT令牌成功');
          } else {
            console.warn('老用户authResult中没有accessToken字段');
          }
          
          this.loginSuccess(userInfo, authResult.userId);
        } else {
          // 没有完整的用户信息，需要获取
          console.log('老用户但缺少用户信息，需要重新获取');
          
          // 保存老用户的基础信息到本地存储
          wx.setStorageSync('userId', authResult.userId);
          wx.setStorageSync('openid', authResult.openid);
          // 保存JWT令牌
          if (authResult.accessToken) {
            wx.setStorageSync('access_token', authResult.accessToken);
            console.log('老用户保存JWT令牌成功:', authResult.accessToken.substring(0, 20) + '...');
          } else {
            console.warn('老用户authResult中没有accessToken字段');
          }
          
          this.showGetUserInfoModal();
        }
      }
    } catch (error) {
      console.error('处理登录结果失败:', error);
      throw error;
    }
  },

  /**
   * 显示获取用户信息的弹窗
   */
  showGetUserInfoModal() {
    console.log('显示获取用户信息弹窗');
    
    // 直接显示弹窗，不需要额外的toast
    wx.showModal({
      title: '🎉 欢迎来到书海拾贝',
      content: '为了给您提供更好的阅读体验和个性化推荐，希望获取您的头像和昵称。您也可以选择稍后设置。',
      confirmText: '立即设置',
      cancelText: '稍后设置',
      success: (res) => {
        console.log('用户弹窗选择结果:', res);
        if (res.confirm) {
          // 用户选择立即完善
          this.getUserProfile();
        } else {
          // 用户选择稍后再说，使用默认信息进入首页
          console.log('用户选择稍后完善，使用默认信息登录');
          this.loginWithDefaultInfo();
        }
      },
      fail: (err) => {
        console.error('显示弹窗失败:', err);
        // 如果弹窗显示失败，直接使用默认信息登录
        this.loginWithDefaultInfo();
      }
    });
  },

  /**
   * 获取用户信息并创建用户记录
   */
  getUserProfile() {
    console.log('开始获取用户信息...');
    
    // 检查用户信息授权状态
    wx.getSetting({
      success: (settingRes) => {
        console.log('用户授权设置:', settingRes.authSetting);
        
        if (settingRes.authSetting['scope.userInfo']) {
          // 用户已经授权，直接获取用户信息
          this.getUserInfoAndUpdate();
        } else {
          // 用户未授权，使用 getUserProfile 获取
          wx.getUserProfile({
            desc: '用于完善用户资料和个性化服务',
            success: async (res) => {
              console.log('获取用户信息成功:', res.userInfo);
              await this.updateUserInfo(res.userInfo);
            },
            fail: (err) => {
              console.error('获取用户信息失败:', err);
              // 用户取消了授权，提供选择：重试或使用默认信息
              wx.showModal({
                title: '获取信息失败',
                content: '未能获取您的头像和昵称，您可以选择重试或暂时使用默认信息进入应用',
                confirmText: '重试',
                cancelText: '使用默认信息',
                success: (modalRes) => {
                  if (modalRes.confirm) {
                    // 用户选择重试，重新显示弹窗
                    setTimeout(() => {
                      this.showGetUserInfoModal();
                    }, 500);
                  } else {
                    // 用户选择使用默认信息
                    this.loginWithDefaultInfo();
                  }
                }
              });
            }
          });
        }
      },
      fail: (err) => {
        console.error('获取授权设置失败:', err);
        // 如果获取授权设置失败，直接尝试 getUserProfile
        wx.getUserProfile({
          desc: '用于完善用户资料和个性化服务',
          success: async (res) => {
            console.log('获取用户信息成功:', res.userInfo);
            await this.updateUserInfo(res.userInfo);
          },
          fail: (err) => {
            console.error('获取用户信息失败:', err);
            // 用户取消了授权，提供选择：重试或使用默认信息
            wx.showModal({
              title: '获取信息失败',
              content: '未能获取您的头像和昵称，您可以选择重试或暂时使用默认信息进入应用',
              confirmText: '重试',
              cancelText: '使用默认信息',
              success: (modalRes) => {
                if (modalRes.confirm) {
                  // 用户选择重试，重新显示弹窗
                  setTimeout(() => {
                    this.showGetUserInfoModal();
                  }, 500);
                } else {
                  // 用户选择使用默认信息
                  this.loginWithDefaultInfo();
                }
              }
            });
          }
        });
      }
    });
  },

  /**
   * 获取用户信息并更新用户（已授权的情况）
   */
  getUserInfoAndUpdate() {
    wx.getUserInfo({
      success: async (res) => {
        console.log('获取用户信息成功:', res.userInfo);
        await this.updateUserInfo(res.userInfo);
      },
      fail: (err) => {
        console.error('获取用户信息失败:', err);
        // 提供选择：重试或使用默认信息
        wx.showModal({
          title: '获取信息失败',
          content: '未能获取您的头像和昵称，您可以选择重试或暂时使用默认信息进入应用',
          confirmText: '重试',
          cancelText: '使用默认信息',
          success: (modalRes) => {
            if (modalRes.confirm) {
              // 用户选择重试
              setTimeout(() => {
                this.getUserInfoAndUpdate();
              }, 500);
            } else {
              // 用户选择使用默认信息
              this.loginWithDefaultInfo();
            }
          }
        });
      }
    });
  },

  /**
   * 更新用户信息
   */
  async updateUserInfo(userInfo) {
    try {
      console.log('开始更新用户信息:', userInfo);
      
      // 构建更新用户信息的请求参数
      const updateData = {
        id: wx.getStorageSync('userId'), // 用户ID
        openid: wx.getStorageSync('openid'), // 微信OpenID
        nickName: userInfo.nickName,
        avatarUrl: userInfo.avatarUrl,
        gender: userInfo.gender,
        country: userInfo.country,
        province: userInfo.province,
        city: userInfo.city,
        language: userInfo.language
      };

      console.log('更新用户信息请求参数:', updateData);
      
      // 调用后端更新用户信息接口
      const response = await request('/user/updateUserAvatar', 'POST', updateData);

      console.log('更新用户信息接口响应:', response);

      if (response.code === 200) {
        // 保存JWT令牌
        if (response.data.accessToken) {
          wx.setStorageSync('access_token', response.data.accessToken);
          console.log('更新用户信息后保存JWT令牌成功');
        } else {
          console.warn('更新用户信息响应中没有accessToken字段');
        }
        
        // 更新成功后，使用返回的用户信息登录
        const updatedUserInfo = {
          nickName: response.data.nickName,
          avatarUrl: response.data.avatarUrl,
          gender: response.data.gender,
          country: response.data.country,
          province: response.data.province,
          city: response.data.city,
          language: response.data.language,
          title: response.data.title // 添加用户称号
        };
        this.loginSuccess(updatedUserInfo, response.data.id);
      } else {
        throw new Error(response.message || '更新用户信息失败');
      }
    } catch (error) {
      console.error('更新用户信息失败:', error);
      // 更新失败时，提供选择：重试或使用默认信息
      wx.showModal({
        title: '更新资料失败',
        content: `更新失败：${error.message || '网络异常'}。您可以选择重试或暂时使用默认信息进入应用。`,
        confirmText: '重试',
        cancelText: '使用默认信息',
        success: (modalRes) => {
          if (modalRes.confirm) {
            // 用户选择重试，重新显示获取信息弹窗
            setTimeout(() => {
              this.showGetUserInfoModal();
            }, 500);
          } else {
            // 用户选择使用默认信息
            this.loginWithDefaultInfo();
          }
        }
      });
    }
  },

  /**
   * 使用默认信息登录（用户选择稍后完善时）
   */
  loginWithDefaultInfo() {
    console.log('使用默认信息登录');
    
    const userId = wx.getStorageSync('userId');
    const openid = wx.getStorageSync('openid');
    
    if (!userId || !openid) {
      console.error('缺少必要的登录信息');
      wx.showToast({
        title: '登录信息异常，请重新登录',
        icon: 'none',
        duration: 3000
      });
      return;
    }
    
    // 创建默认的用户信息
    const defaultUserInfo = {
      nickName: '书友' + userId.toString().slice(-4), // 使用用户ID后4位作为默认昵称
      avatarUrl: '/static/avatar1.png', // 默认头像
      gender: 0,
      country: '',
      province: '',
      city: '',
      language: 'zh_CN',
      title: '流萤' // 默认称号
    };
    
    console.log('使用默认用户信息:', defaultUserInfo);
    
    // 调用登录成功处理，标记为默认信息
    this.loginSuccess(defaultUserInfo, userId, true);
  },

  /**
   * 登录成功处理
   */
  loginSuccess(userInfo, userId, isDefaultInfo = false) {
    // 保存用户信息到全局数据
    const app = getApp();
    app.globalData.userInfo = userInfo;
    app.globalData.userId = userId;
    app.globalData.userProfile = {
      title: userInfo.title || '流萤' // 保存用户称号
    };
    
    // 设置欢迎卡片显示标志
    app.globalData.shouldShowWelcomeCard = true;
    
    // 保存到本地存储
    wx.setStorageSync('userInfo', userInfo);
    wx.setStorageSync('userId', userId);
    wx.setStorageSync('userTitle', userInfo.title || '流萤'); // 保存用户称号
    
    // 注意：access_token在前面的流程中已经保存，这里不需要重复保存
    
    // 更新页面数据
    this.setData({
      userInfo: userInfo,
      hasUserInfo: true
    });
    
    // 根据是否为默认信息显示不同提示
    if (isDefaultInfo) {
      wx.showToast({
        title: '欢迎来到书海拾贝！',
        icon: 'success',
        duration: 1500
      });
      
      // 默认信息登录，较快跳转，并提示可以完善资料
      setTimeout(() => {
        wx.switchTab({
          url: '/pages/home/index',
          success: () => {
            // 跳转成功后显示提示
            setTimeout(() => {
              wx.showToast({
                title: '可在设置中完善个人资料',
                icon: 'none',
                duration: 2000
              });
            }, 1000);
          }
        });
      }, 1500);
    } else {
      wx.showToast({
        title: '个人资料设置完成！',
        icon: 'success',
        duration: 2000
      });
      
      // 完整信息登录，稍慢跳转，让用户看到成功状态
      setTimeout(() => {
        wx.switchTab({
          url: '/pages/home/index'
        });
      }, 2000);
    }
    
    // 验证令牌是否正确保存
    const savedToken = wx.getStorageSync('access_token');
    console.log('登录成功，JWT令牌保存状态:', !!savedToken);
  },

  /**
   * 点击登录按钮
   */
  onLoginTap() {
    console.log('用户点击登录按钮');
    this.wxLogin();
  }
});
